template<class T>
size_t ttfTexGenerator::render( T&& note, LccStuffCollector::TTFParser::unicodes line, LccToolbox::block<size_t>* texCordInds_p){
	size_t count=0;

	// < check if have note in styleSetting >
	auto itStyleSetting=styleSettings.find(std::forward<T>(note));
	if(itStyleSetting=styleSettings.end()) return false;

	// < get the glyphlist >
	LccToolbox::block<size_t> itemInds;
	parser.parse(line,itemInds);
	typedef theItem::simpleCase::points::elementType pointType;

	// {setting the frame}

	// < render per glyph from glyphlist >
	for(size_t i=0;i<itemInds.size();++i)
	{	glyfItem& theItem=parser.glyfItems[itemInds[i]];
		if(theItem.is_simple)
		{	// [ loop to render the contours ]
			for(size_t j=0;j<theItem.contours.size();++j)
			{	// < data prepare >
				// [ slots prepare ]
				LccToolbox::Block/*LccToolbox::block<pointType>*/ output;
				LccToolbox::Block/*LccToolbox::block<unsigned int>*/ index_extreme,index_h1,index_h,index_h2;
				// [ get contour points & extre points ... which for render ]
				// * Bezier // output might produce the extreme point, might such as 'o' 'e' which have curve in scan direction
				Bezier::InputWrapper<pointType> iwrap_bezier;
				Bezier::OutputWrapper<pointType> owrap_bezier;
				iwrap_bezier.element=[&theItem,&j](size_t i)->pointType&{return theItem.contours[j]._points[i];};
				iwrap_bezier.size=[&theItem,&j]()->size_t{return theItem.contours[j]._points.size();};
				iwrap_bezier.is_onCurve=[&theItem,&j](size_t i)->bool{return (theItem.simple.contours[j]._flags[i]&1);};
				owrap_bezier.element=[&output](size_t i)->pointType&{return *(output.ptras<pointType>(i));};
				owrap_bezier.size=[&output]()->size_t{return output.sizeas<pointType>();};
				owrap_bezier.clear=[&output]{output.clear();};
				owrap_bezier.grow=[&output](size_t n){output.grow(n*sizeof(pointType));};
				owrap_bezier.shrink=[&output](size_t n){output.shrink(n*sizeof(pointType));};
				Bezier::process(iwrap_bezier,owrap_bezier);
				// * extreme and special point index
				extremeNhorz::InputWrapper<pointType> iwrap_eNh;
				extremeNhorz::OutputWrapper<pointType,unsigned int> owrap_e;
				extremeNhorz::OutputWrapper<pointType,unsigned int> owrap_h1;
				extremeNhorz::OutputWrapper<pointType,unsigned int> owrap_h;
				extremeNhorz::OutputWrapper<pointType,unsigned int> owrap_h2;
				iwrap_eNh.element=[&output](size_t i)->pointType&{return *(output.ptras<pointType>(i));};
				iwrap_eNh.size=[&output]->size_t{return output.sizeas<pointType>();};
				iwrap_eNh.cut_direction=glm::vec3{1,0,0};
				owrap_bezier.element=[&index_extreme](size_t i)->typename unsigned int&{return *(index_extreme.ptras<unsigned int>(i));};
				owrap_bezier.size=[&index_extreme]()->size_t{return index_extreme.sizeas<unsigned int>();};
				owrap_bezier.clear=[&index_extreme]{index_extreme.clear();};
				owrap_bezier.grow=[&index_extreme](size_t n){index_extreme.grow(n*sizeof(unsigned int));};
				owrap_h1.element=[&index_h1](size_t i)->typename unsigned int&{return *(index_h1.ptras<unsigned int>(i));};
				owrap_h1.size=[&index_h1]()->size_t{return index_h1.sizeas<unsigned int>();};
				owrap_h1.clear=[&index_h1]{index_h1.clear();};
				owrap_h1.grow=[&index_h1](size_t n){index_h1.grow(n*sizeof(unsigned int));};
				owrap_h.element=[&index_h](size_t i)->typename unsigned int&{return *(index_h.ptras<unsigned int>(i));};
				owrap_h.size=[&index_h]()->size_t{return index_h.sizeas<unsigned int>();};
				owrap_h.clear=[&index_h]{index_h.clear();};
				owrap_h.grow=[&index_h](size_t n){index_h.grow(n*sizeof(unsigned int));};
				owrap_h2.element=[&index_h2](size_t i)->typename unsigned int&{return *(index_h2.ptras<unsigned int>(i));};
				owrap_h2.size=[&index_h2]()->size_t{return index_h2.sizeas<unsigned int>();};
				owrap_h2.clear=[&index_h2]{index_h2.clear();};
				owrap_h2.grow=[&index_h2](size_t n){index_h2.grow(n*sizeof(unsigned int));};
				extremeNhorz::process(iwrap_eNh,owrap_e,owrap_h1,owrap_h,owrap_h2);

				// < render prepare >
				// [ trans the data into GLobj ]
				GLC->modifyBuffer(GLobjSlots.buffer(0),output.ptr(),output.size());
				// { refresh the vertexArray }
				GLC->modifyIndex(GLobjSlots.index(0),index_extreme.ptr(),index_extreme.size());// this func should auto maticaly fresh the bind
				GLC->modifyIndex(GLobjSlots.index(1),index_h1.ptr(),index_h1.size());// this func should auto maticaly fresh the bind
				GLC->modifyIndex(GLobjSlots.index(2),index_h.ptr(),index_h.size());
				GLC->modifyIndex(GLobjSlots.index(3),index_h2.ptr(),index_h2.size());

				// [ get the render position & some related info ]
				const styleSetting::coord position=(*itStyleSetting)++;
				const styleSetting::outline& glyphOutline=itStyleSetting->glyphOutline;

				// < render >
				// [ render contour ]
				/* GL part, bind the specific texture
				 *  the idea of render: render as lines
				 *  diff line have diff color
				**  between two diff color's point will in the glyph
				*   and the extreme point will see as two diff color line	*/
				// { fitSingleFontBoard(...); } // bind the specific texture, fit the size ...
				GLC->bindFrameBuffer(glyphUnitFrame);
				glViewport(0,0,glyphOutline.w,glyphOutline.h);
				GLC->useShader(shader_loop);
				GLC->drawArray(AIA_AUTO,GLobjSlots.array(0));// output
				GLC->useShader(shader_point);
				GLC->uniform(smark{1},glm::vec3{1,1,1});
				GLC->drawIndex(AIA_AUTO,GLobjSlots.index(0));// index_extreme
				GLC->uniform(smark{1},glm::vec3{1,0,0});
				GLC->drawIndex(AIA_AUTO,GLobjSlots.index(1));// index_h1
				GLC->uniform(smark{1},glm::vec3{0,1,0});
				GLC->drawIndex(AIA_AUTO,GLobjSlots.index(2));// index_h
				GLC->uniform(smark{1},glm::vec3{0,0,1});
				GLC->drawIndex(AIA_AUTO,GLobjSlots.index(3));// index_h2
				// [ scan to final texture ]
				// { fitWholeFontBoard(...) } // bind the specific texture, fit the size ...
				GLC->bindFrameBuffer(glyphClusterFrame);
				glViewport(position.x-glyphOutline.w/2,position.y-glyphOutline.h/2,glyphOutline.w,glyphOutline.h);
				GLC->useShader(shader_scan);
				GLC->uniform(smark{1},glm::ivec2{glyphOutline.w,glyphOutline.h});
				GLC->draw(AIA_AUTO,board);
			}
			// { check if render success then record the cord & ++count }
		}
		// { else component case }
	}

	return count;
}